/**
 * 项目加载器 - 支持离线和在线两种模式
 */

class ProjectLoader {
    constructor() {
        this.config = null;
        this.projectData = null;
        this.sceneData = null;
    }

    /**
     * 初始化加载器
     */
    async init() {
        try {
            console.log('   ┌─────────────────────────────────────────────');
            console.log('   │ 项目加载器初始化');
            console.log('   └─────────────────────────────────────────────');
            
            // 读取配置文件
            console.log('   → 读取配置文件...');
            this.config = await this.loadConfig();
            console.log('   ✓ 配置文件读取成功');
            console.log('     - 模式:', this.config.mode);
            if (this.config.mode === 'offline') {
                console.log('     - 项目文件夹:', this.config.offline.projectFolder);
            } else if (this.config.mode === 'online') {
                console.log('     - 后端URL:', this.config.online.backendUrl);
                console.log('     - 项目ID:', this.config.online.projectId);
            }

            // 根据模式加载项目
            if (this.config.mode === 'offline') {
                console.log('   → 使用离线模式加载...');
                await this.loadOfflineProject();
            } else if (this.config.mode === 'online') {
                console.log('   → 使用在线模式加载...');
                await this.loadOnlineProject();
            } else {
                throw new Error('未知的加载模式: ' + this.config.mode);
            }

            console.log('   ✓ 项目加载器初始化完成');
            console.log('');

            return {
                project: this.projectData,
                scene: this.sceneData,
                config: this.config
            };

        } catch (error) {
            console.error('   ✗ 项目加载器初始化失败');
            console.error('   ✗ 错误:', error.message);
            throw error;
        }
    }

    /**
     * 加载配置文件
     */
    async loadConfig() {
        try {
            console.log('     → 请求: /project/config.json');
            const response = await fetch('/project/config.json');
            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }
            const config = await response.json();
            console.log('     ✓ 配置文件解析成功');
            return config;
        } catch (error) {
            console.warn('     ⚠️  配置文件读取失败:', error.message);
            console.warn('     → 使用默认配置');
            // 返回默认配置
            return {
                mode: 'offline',
                offline: {
                    projectFolder: '',
                    defaultScene: 'auto'
                }
            };
        }
    }

    /**
     * 离线模式 - 加载本地项目
     */
    async loadOfflineProject() {
        const projectFolder = this.config.offline.projectFolder;
        console.log('     → 项目文件夹:', projectFolder);
        
        if (!projectFolder) {
            throw new Error('未配置项目文件夹名称');
        }

        const projectPath = `/project/${projectFolder}`;
        console.log('     → 项目路径:', projectPath);

        try {
            // 步骤 1: 加载 project.json
            console.log('     → 步骤 1: 加载项目配置...');
            const projectResponse = await fetch(`${projectPath}/project.json`);
            if (!projectResponse.ok) {
                throw new Error(`项目配置文件不存在 (${projectResponse.status})`);
            }
            this.projectData = await projectResponse.json();
            console.log('     ✓ 项目配置加载成功');
            console.log('       - 项目名:', this.projectData.name);
            console.log('       - 场景数:', this.projectData.scenes?.length || 0);

            // 步骤 2: 确定要加载的场景
            console.log('     → 步骤 2: 确定加载场景...');
            let sceneId = this.config.offline.defaultScene;
            if (sceneId === 'auto' || !sceneId) {
                if (this.projectData.scenes && this.projectData.scenes.length > 0) {
                    sceneId = this.projectData.scenes[0].id;
                    console.log('     ✓ 自动选择第一个场景:', sceneId);
                } else {
                    throw new Error('项目中没有场景');
                }
            } else {
                console.log('     ✓ 使用配置的场景:', sceneId);
            }

            // 步骤 3: 加载场景数据
            console.log('     → 步骤 3: 加载场景数据...');
            const scenePath = `${projectPath}/scenes/${sceneId}`;
            
            // 3.1: 加载 config.json
            console.log('       → 加载场景配置...');
            const sceneConfigResponse = await fetch(`${scenePath}/config.json`);
            if (!sceneConfigResponse.ok) {
                throw new Error(`场景配置文件不存在 (${sceneConfigResponse.status})`);
            }
            const sceneConfig = await sceneConfigResponse.json();
            console.log('       ✓ 场景配置加载成功');

            // 3.2: 加载 tree.json (树结构)
            console.log('       → 加载场景树结构...');
            const treeResponse = await fetch(`${scenePath}/tree.json`);
            if (!treeResponse.ok) {
                throw new Error(`场景树文件不存在 (${treeResponse.status})`);
            }
            const treeData = await treeResponse.json();
            console.log('       ✓ 场景树结构加载成功');
            console.log('         - 版本:', treeData.version || '1.0');
            console.log('         - 节点数:', treeData.nodeCount || 0);
            
            // 3.3: 加载 nodes.json (节点配置)
            console.log('       → 加载节点配置...');
            const nodesResponse = await fetch(`${scenePath}/nodes.json`);
            let nodesData = null;
            
            if (nodesResponse.ok) {
                nodesData = await nodesResponse.json();
                console.log('       ✓ 节点配置加载成功');
                console.log('         - 节点数:', nodesData.nodes?.length || 0);
            } else {
                console.log('       ⚠️  节点配置文件不存在，使用旧版格式');
            }

            // 组合场景数据
            this.sceneData = {
                id: sceneId,
                name: sceneConfig.name || '默认场景',
                config: sceneConfig,
                tree: treeData,
                nodes: nodesData,
                projectPath: projectPath,
                version: treeData.version || '1.0'
            };

            console.log('     ✓ 离线项目加载完成');

        } catch (error) {
            console.error('     ✗ 离线项目加载失败:', error.message);
            throw error;
        }
    }

    /**
     * 在线模式 - 从服务器加载项目
     */
    async loadOnlineProject() {
        const { backendUrl, projectId, sceneId, timeout } = this.config.online;

        console.log('     → 后端URL:', backendUrl);
        console.log('     → 项目ID:', projectId);
        console.log('     → 超时时间:', timeout, 'ms');

        if (!backendUrl || !projectId) {
            throw new Error('在线模式配置不完整 (缺少 backendUrl 或 projectId)');
        }

        try {
            // 步骤 1: 加载项目数据
            console.log('     → 步骤 1: 请求项目数据...');
            const projectUrl = `${backendUrl}/api/projects/${projectId}`;
            console.log('       → URL:', projectUrl);
            
            const projectResponse = await this.fetchWithTimeout(projectUrl, timeout);
            const responseData = await projectResponse.json();
            
            // 解包服务器响应（服务器返回 {success, data} 格式）
            if (responseData.success && responseData.data) {
                this.projectData = responseData.data;
            } else {
                throw new Error('服务器返回数据格式错误');
            }
            
            console.log('     ✓ 项目数据加载成功');
            console.log('       - 项目名:', this.projectData.name);
            console.log('       - 项目ID:', this.projectData.id);
            console.log('       - 场景数:', this.projectData.scenes?.length || 0);
            console.log('       - 场景列表:', this.projectData.scenes);

            // 步骤 2: 确定要加载的场景
            console.log('     → 步骤 2: 确定加载场景...');
            let targetSceneId = sceneId;
            if (!targetSceneId) {
                if (this.projectData.scenes && this.projectData.scenes.length > 0) {
                    targetSceneId = this.projectData.scenes[0].id;
                    console.log('     ✓ 自动选择第一个场景:', targetSceneId);
                } else {
                    throw new Error('项目中没有场景');
                }
            } else {
                console.log('     ✓ 使用配置的场景:', targetSceneId);
            }

            // 步骤 3: 加载场景树数据
            console.log('     → 步骤 3: 请求场景树数据...');
            const treeUrl = `${backendUrl}/api/projects/${projectId}/scenes/${targetSceneId}/tree`;
            console.log('       → URL:', treeUrl);
            
            const treeResponse = await this.fetchWithTimeout(treeUrl, timeout);
            const treeData = await treeResponse.json();
            
            // 从项目数据中获取场景基本信息
            const sceneInfo = this.projectData.scenes.find(s => s.id === targetSceneId);
            if (!sceneInfo) {
                throw new Error('场景信息不存在');
            }
            
            // 组合场景数据
            this.sceneData = {
                ...sceneInfo,
                tree: treeData,
                projectPath: `${backendUrl}/projects/${projectId}`
            };
            
            console.log('     ✓ 场景数据加载成功');
            console.log('       - 场景名:', this.sceneData.name);
            console.log('       - 场景类型:', this.sceneData.type);
            console.log('       - 节点数:', this.sceneData.tree?.children?.length || 0);

            console.log('     ✓ 在线项目加载完成');

        } catch (error) {
            console.error('     ✗ 在线项目加载失败:', error.message);
            if (error.name === 'AbortError') {
                console.error('     ✗ 原因: 请求超时');
            }
            throw error;
        }
    }

    /**
     * 带超时的 fetch
     */
    async fetchWithTimeout(url, timeout = 5000) {
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), timeout);
        const startTime = performance.now();

        try {
            console.log('       → 发送请求...');
            const response = await fetch(url, {
                signal: controller.signal
            });
            clearTimeout(timeoutId);

            const elapsed = (performance.now() - startTime).toFixed(2);
            console.log(`       → 收到响应 (耗时: ${elapsed}ms)`);

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            console.log('       ✓ 请求成功');
            return response;
        } catch (error) {
            clearTimeout(timeoutId);
            const elapsed = (performance.now() - startTime).toFixed(2);
            console.error(`       ✗ 请求失败 (耗时: ${elapsed}ms)`);
            
            if (error.name === 'AbortError') {
                throw new Error(`请求超时 (>${timeout}ms)`);
            }
            throw error;
        }
    }

    /**
     * 获取模型完整路径
     */
    getModelPath(modelPath) {
        if (!modelPath) return null;

        // 如果是完整 URL，直接返回
        if (modelPath.startsWith('http://') || modelPath.startsWith('https://')) {
            return modelPath;
        }

        // 离线模式，使用本地路径
        if (this.config.mode === 'offline') {
            return modelPath;
        }

        // 在线模式，拼接服务器路径
        if (this.config.mode === 'online') {
            const baseUrl = this.config.online.backendUrl;
            return modelPath.startsWith('/') ? `${baseUrl}${modelPath}` : `${baseUrl}/${modelPath}`;
        }

        return modelPath;
    }
}

export default ProjectLoader;

